home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / DJGPP / DJ111M3.ZIP / src / patch / patch.c
C/C++ Source or Header  |  1994-02-05  |  21KB  |  875 lines
  1. char rcsid[] =
  2.     "$Header: patch.c,v 2.0.2.0 90/05/01 22:17:50 davison Locked $";
  3.  
  4. /* patch - a program to apply diffs to original files
  5.  *
  6.  * Copyright 1986, Larry Wall
  7.  *
  8.  * This program may be copied as long as you don't try to make any
  9.  * money off of it, or pretend that you wrote it.
  10.  *
  11.  * $Log:    patch.c,v $
  12.  * Revision 2.0.2.0  90/05/01  22:17:50  davison
  13.  * patch12u: unidiff support added
  14.  * 
  15.  * Revision 2.0.1.6  88/06/22  20:46:39  lwall
  16.  * patch12: rindex() wasn't declared
  17.  * 
  18.  * Revision 2.0.1.5  88/06/03  15:09:37  lwall
  19.  * patch10: exit code improved.
  20.  * patch10: better support for non-flexfilenames.
  21.  * 
  22.  * Revision 2.0.1.4  87/02/16  14:00:04  lwall
  23.  * Short replacement caused spurious "Out of sync" message.
  24.  * 
  25.  * Revision 2.0.1.3  87/01/30  22:45:50  lwall
  26.  * Improved diagnostic on sync error.
  27.  * Moved do_ed_script() to pch.c.
  28.  * 
  29.  * Revision 2.0.1.2  86/11/21  09:39:15  lwall
  30.  * Fuzz factor caused offset of installed lines.
  31.  * 
  32.  * Revision 2.0.1.1  86/10/29  13:10:22  lwall
  33.  * Backwards search could terminate prematurely.
  34.  * 
  35.  * Revision 2.0  86/09/17  15:37:32  lwall
  36.  * Baseline for netwide release.
  37.  * 
  38.  * Revision 1.5  86/08/01  20:53:24  lwall
  39.  * Changed some %d's to %ld's.
  40.  * Linted.
  41.  * 
  42.  * Revision 1.4  86/08/01  19:17:29  lwall
  43.  * Fixes for machines that can't vararg.
  44.  * Added fuzz factor.
  45.  * Generalized -p.
  46.  * General cleanup.
  47.  * 
  48.  * 85/08/15 van%ucbmonet@berkeley
  49.  * Changes for 4.3bsd diff -c.
  50.  *
  51.  * Revision 1.3  85/03/26  15:07:43  lwall
  52.  * Frozen.
  53.  * 
  54.  * Revision 1.2.1.9  85/03/12  17:03:35  lwall
  55.  * Changed pfp->_file to fileno(pfp).
  56.  * 
  57.  * Revision 1.2.1.8  85/03/12  16:30:43  lwall
  58.  * Check i_ptr and i_womp to make sure they aren't null before freeing.
  59.  * Also allow ed output to be suppressed.
  60.  * 
  61.  * Revision 1.2.1.7  85/03/12  15:56:13  lwall
  62.  * Added -p option from jromine@uci-750a.
  63.  * 
  64.  * Revision 1.2.1.6  85/03/12  12:12:51  lwall
  65.  * Now checks for normalness of file to patch.
  66.  * 
  67.  * Revision 1.2.1.5  85/03/12  11:52:12  lwall
  68.  * Added -D (#ifdef) option from joe@fluke.
  69.  * 
  70.  * Revision 1.2.1.4  84/12/06  11:14:15  lwall
  71.  * Made smarter about SCCS subdirectories.
  72.  * 
  73.  * Revision 1.2.1.3  84/12/05  11:18:43  lwall
  74.  * Added -l switch to do loose string comparison.
  75.  * 
  76.  * Revision 1.2.1.2  84/12/04  09:47:13  lwall
  77.  * Failed hunk count not reset on multiple patch file.
  78.  * 
  79.  * Revision 1.2.1.1  84/12/04  09:42:37  lwall
  80.  * Branch for sdcrdcf changes.
  81.  * 
  82.  * Revision 1.2  84/11/29  13:29:51  lwall
  83.  * Linted.  Identifiers uniqified.  Fixed i_ptr malloc() bug.  Fixed
  84.  * multiple calls to mktemp().  Will now work on machines that can only
  85.  * read 32767 chars.  Added -R option for diffs with new and old swapped.
  86.  * Various cosmetic changes.
  87.  * 
  88.  * Revision 1.1  84/11/09  17:03:58  lwall
  89.  * Initial revision
  90.  * 
  91.  */
  92.  
  93. #include "INTERN.h"
  94. #include "common.h"
  95. #include "EXTERN.h"
  96. #include "version.h"
  97. #include "util.h"
  98. #include "pch.h"
  99. #include "inp.h"
  100.  
  101. /* procedures */
  102.  
  103. void reinitialize_almost_everything();
  104. void get_some_switches();
  105. LINENUM locate_hunk();
  106. void abort_hunk();
  107. void apply_hunk();
  108. void init_output();
  109. void init_reject();
  110. void copy_till();
  111. void spew_output();
  112. void dump_line();
  113. bool patch_match();
  114. bool similar();
  115. void re_input();
  116. void my_exit();
  117.  
  118. /* Nonzero if -R was specified on command line.  */
  119. static int reverse_flag_specified = FALSE;
  120.  
  121. /* Apply a set of diffs as appropriate. */
  122.  
  123. main(argc,argv)
  124. int argc;
  125. char **argv;
  126. {
  127.     LINENUM where;
  128.     LINENUM newwhere;
  129.     LINENUM fuzz;
  130.     LINENUM mymaxfuzz;
  131.     int hunk = 0;
  132.     int failed = 0;
  133.     int failtotal = 0;
  134.     int i;
  135.  
  136.     setbuf(stderr, serrbuf);
  137.     for (i = 0; i<MAXFILEC; i++)
  138.     filearg[i] = Nullch;
  139.  
  140.     /* Cons up the names of the temporary files.  */
  141.     {
  142.       /* Directory for temporary files.  */
  143.       char *tmpdir;
  144.       int tmpname_len;
  145.  
  146.       tmpdir = getenv ("TMPDIR");
  147.       if (tmpdir == NULL)
  148.         tmpdir = getenv("TMP");
  149.       if (tmpdir == NULL)
  150.         tmpdir = getenv("TEMP");
  151.       if (tmpdir == NULL) {
  152.     tmpdir = ".";
  153.       }
  154.       if (tmpdir[strlen(tmpdir)-1] == '/')
  155.         tmpdir[strlen(tmpdir)-1] = 0;
  156.       tmpname_len = strlen (tmpdir) + 20;
  157.  
  158.       TMPOUTNAME = (char *) malloc (tmpname_len);
  159.       strcpy (TMPOUTNAME, tmpdir);
  160.       strcat (TMPOUTNAME, "/poXXXXXX");
  161.       Mktemp(TMPOUTNAME);
  162.  
  163.       TMPINNAME = (char *) malloc (tmpname_len);
  164.       strcpy (TMPINNAME, tmpdir);
  165.       strcat (TMPINNAME, "/piXXXXXX");
  166.       Mktemp(TMPINNAME);
  167.  
  168.       TMPREJNAME = (char *) malloc (tmpname_len);
  169.       strcpy (TMPREJNAME, tmpdir);
  170.       strcat (TMPREJNAME, "/prXXXXXX");
  171.       Mktemp(TMPREJNAME);
  172.  
  173.       TMPPATNAME = (char *) malloc (tmpname_len);
  174.       strcpy (TMPPATNAME, tmpdir);
  175.       strcat (TMPPATNAME, "/ppXXXXXX");
  176.       Mktemp(TMPPATNAME);
  177.     }
  178.  
  179.     /* parse switches */
  180.     Argc = argc;
  181.     Argv = argv;
  182.     get_some_switches();
  183.     
  184.     /* make sure we clean up /tmp in case of disaster */
  185.     set_signals(0);
  186.  
  187.     for (
  188.     open_patch_file(filearg[1]);
  189.     there_is_another_patch();
  190.     reinitialize_almost_everything()
  191.     ) {                    /* for each patch in patch file */
  192.  
  193.     if (outname == Nullch)
  194.         outname = savestr(filearg[0]);
  195.     
  196.     /* initialize the patched file */
  197.     if (!skip_rest_of_patch)
  198.         init_output(TMPOUTNAME);
  199.     
  200.     /* for ed script just up and do it and exit */
  201.     if (diff_type == ED_DIFF) {
  202.         do_ed_script();
  203.         continue;
  204.     }
  205.     
  206.     /* initialize reject file */
  207.     init_reject(TMPREJNAME);
  208.     
  209.     /* find out where all the lines are */
  210.     if (!skip_rest_of_patch)
  211.         scan_input(filearg[0]);
  212.     
  213.     /* from here on, open no standard i/o files, because malloc */
  214.     /* might misfire and we can't catch it easily */
  215.     
  216.     /* apply each hunk of patch */
  217.     hunk = 0;
  218.     failed = 0;
  219.     out_of_mem = FALSE;
  220.     while (another_hunk()) {
  221.         hunk++;
  222.         fuzz = Nulline;
  223.         mymaxfuzz = pch_context();
  224.         if (maxfuzz < mymaxfuzz)
  225.         mymaxfuzz = maxfuzz;
  226.         if (!skip_rest_of_patch) {
  227.         do {
  228.             where = locate_hunk(fuzz);
  229.             if (hunk == 1 && where == Nulline && !force) {
  230.                         /* dwim for reversed patch? */
  231.             if (!pch_swap()) {
  232.                 if (fuzz == Nulline)
  233.                 say1(
  234. "Not enough memory to try swapped hunk!  Assuming unswapped.\n");
  235.                 continue;
  236.             }
  237.             reverse = !reverse;
  238.             where = locate_hunk(fuzz);  /* try again */
  239.             if (where == Nulline) {        /* didn't find it swapped */
  240.                 if (!pch_swap())         /* put it back to normal */
  241.                 fatal1("Lost hunk on alloc error!\n");
  242.                 reverse = !reverse;
  243.             }
  244.             else if (noreverse) {
  245.                 if (!pch_swap())         /* put it back to normal */
  246.                 fatal1("Lost hunk on alloc error!\n");
  247.                 reverse = !reverse;
  248.                 say1(
  249. "Ignoring previously applied (or reversed) patch.\n");
  250.                 skip_rest_of_patch = TRUE;
  251.             }
  252.             else {
  253.                 ask3(
  254. "%seversed (or previously applied) patch detected!  %s -R? [y] ",
  255.                 reverse ? "R" : "Unr",
  256.                 reverse ? "Assume" : "Ignore");
  257.                 if (*buf == 'n') {
  258.                 ask1("Apply anyway? [n] ");
  259.                 if (*buf != 'y')
  260.                     skip_rest_of_patch = TRUE;
  261.                 where = Nulline;
  262.                 reverse = !reverse;
  263.                 if (!pch_swap())  /* put it back to normal */
  264.                     fatal1("Lost hunk on alloc error!\n");
  265.                 }
  266.             }
  267.             }
  268.         } while (!skip_rest_of_patch && where == Nulline &&
  269.             ++fuzz <= mymaxfuzz);
  270.  
  271.         if (skip_rest_of_patch) {        /* just got decided */
  272.             Fclose(ofp);
  273.             ofp = Nullfp;
  274.         }
  275.         }
  276.  
  277.         newwhere = pch_newfirst() + last_offset;
  278.         if (skip_rest_of_patch) {
  279.         abort_hunk();
  280.         failed++;
  281.         if (verbose)
  282.             say3("Hunk #%d ignored at %ld.\n", hunk, newwhere);
  283.         }
  284.         else if (where == Nulline) {
  285.         abort_hunk();
  286.         failed++;
  287.         if (verbose)
  288.             say3("Hunk #%d failed at %ld.\n", hunk, newwhere);
  289.         }
  290.         else {
  291.         apply_hunk(where);
  292.         if (verbose) {
  293.             say3("Hunk #%d succeeded at %ld", hunk, newwhere);
  294.             if (fuzz)
  295.             say2(" with fuzz %ld", fuzz);
  296.             if (last_offset)
  297.             say3(" (offset %ld line%s)",
  298.                 last_offset, last_offset==1L?"":"s");
  299.             say1(".\n");
  300.         }
  301.         }
  302.     }
  303.  
  304.     if (out_of_mem && using_plan_a) {
  305.         Argc = Argc_last;
  306.         Argv = Argv_last;
  307.         say1("\n\nRan out of memory using Plan A--trying again...\n\n");
  308.         continue;
  309.     }
  310.     
  311.     assert(hunk);
  312.     
  313.     /* finish spewing out the new file */
  314.     if (!skip_rest_of_patch)
  315.         spew_output();
  316.     
  317.     /* and put the output where desired */
  318.     ignore_signals();
  319.     if (!skip_rest_of_patch) {
  320.         if (move_file(TMPOUTNAME, outname) < 0) {
  321.         toutkeep = TRUE;
  322.         chmod(TMPOUTNAME, filemode);
  323.         }
  324.         else
  325.         chmod(outname, filemode);
  326.     }
  327.     Fclose(rejfp);
  328.     rejfp = Nullfp;
  329.     if (failed) {
  330.         failtotal += failed;
  331.         if (!*rejname) {
  332.         Strcpy(rejname, outname);
  333. #ifndef FLEXFILENAMES
  334.         {
  335.             char *rindex();
  336.             char *s = rindex(rejname,'/');
  337.  
  338.             if (!s)
  339.             s = rejname;
  340.             if (strlen(s) > 13)
  341.             if (s[12] == '.')    /* try to preserve difference */
  342.                 s[12] = s[13];    /* between .h, .c, .y, etc. */
  343.             s[13] = '\0';
  344.         }
  345. #endif
  346.         Strcat(rejname, REJEXT);
  347.         }
  348.         if (skip_rest_of_patch) {
  349.         say4("%d out of %d hunks ignored--saving rejects to %s\n",
  350.             failed, hunk, rejname);
  351.         }
  352.         else {
  353.         say4("%d out of %d hunks failed--saving rejects to %s\n",
  354.             failed, hunk, rejname);
  355.         }
  356.         if (move_file(TMPREJNAME, rejname) < 0)
  357.         trejkeep = TRUE;
  358.     }
  359.     set_signals(1);
  360.     }
  361.     my_exit(failtotal);
  362. }
  363.  
  364. /* Prepare to find the next patch to do in the patch file. */
  365.  
  366. void
  367. reinitialize_almost_everything()
  368. {
  369.     re_patch();
  370.     re_input();
  371.  
  372.     input_lines = 0;
  373.     last_frozen_line = 0;
  374.  
  375.     filec = 0;
  376.     if (filearg[0] != Nullch && !out_of_mem) {
  377.     free(filearg[0]);
  378.     filearg[0] = Nullch;
  379.     }
  380.  
  381.     if (outname != Nullch) {
  382.     free(outname);
  383.     outname = Nullch;
  384.     }
  385.  
  386.     last_offset = 0;
  387.  
  388.     diff_type = 0;
  389.  
  390.     if (revision != Nullch) {
  391.     free(revision);
  392.     revision = Nullch;
  393.     }
  394.  
  395.     reverse = reverse_flag_specified;
  396.     skip_rest_of_patch = FALSE;
  397.  
  398.     get_some_switches();
  399.  
  400.     if (filec >= 2)
  401.     fatal1("You may not change to a different patch file.\n");
  402. }
  403.  
  404. static char *
  405. nextarg()
  406. {
  407.     if (!--Argc)
  408.     fatal2("patch: missing argument after `%s'\n", *Argv);
  409.     return *++Argv;
  410. }
  411.  
  412. /* Process switches and filenames up to next '+' or end of list. */
  413.  
  414. void
  415. get_some_switches()
  416. {
  417.     Reg1 char *s;
  418.  
  419.     rejname[0] = '\0';
  420.     Argc_last = Argc;
  421.     Argv_last = Argv;
  422.     if (!Argc)
  423.     return;
  424.     for (Argc--,Argv++; Argc; Argc--,Argv++) {
  425.     s = Argv[0];
  426.     if (strEQ(s, "+")) {
  427.         return;            /* + will be skipped by for loop */
  428.     }
  429.     if (*s != '-' || !s[1]) {
  430.         if (filec == MAXFILEC)
  431.         fatal1("patch: Too many file arguments.\n");
  432.         filearg[filec++] = savestr(s);
  433.     }
  434.     else {
  435.         switch (*++s) {
  436.         case 'b':
  437.         origext = savestr(nextarg());
  438.         break;
  439.         case 'B':
  440.         origprae = savestr(nextarg());
  441.         break;
  442.         case 'c':
  443.         diff_type = CONTEXT_DIFF;
  444.         break;
  445.         case 'd':
  446.         if (!*++s)
  447.             s = nextarg();
  448.         if (chdir(s) < 0)
  449.             fatal2("Can't cd to %s.\n", s);
  450.         break;
  451.         case 'D':
  452.             do_defines = TRUE;
  453.         if (!*++s)
  454.             s = nextarg();
  455.         if (!isalpha(*s) && '_' != *s)
  456.             fatal1("Argument to -D not an identifier.\n");
  457.         Sprintf(if_defined, "#ifdef %s\n", s);
  458.         Sprintf(not_defined, "#ifndef %s\n", s);
  459.         Sprintf(end_defined, "#endif /* %s */\n", s);
  460.         break;
  461.         case 'e':
  462.         diff_type = ED_DIFF;
  463.         break;
  464.         case 'f':
  465.         force = TRUE;
  466.         break;
  467.         case 'F':
  468.         if (*++s == '=')
  469.             s++;
  470.         maxfuzz = atoi(s);
  471.         break;
  472.         case 'l':
  473.         canonicalize = TRUE;
  474.         break;
  475.         case 'n':
  476.         diff_type = NORMAL_DIFF;
  477.         break;
  478.         case 'N':
  479.         noreverse = TRUE;
  480.         break;
  481.         case 'o':
  482.         outname = savestr(nextarg());
  483.         break;
  484.         case 'p':
  485.         if (*++s == '=')
  486.             s++;
  487.         strippath = atoi(s);
  488.         break;
  489.         case 'r':
  490.         Strcpy(rejname, nextarg());
  491.         break;
  492.         case 'R':
  493.         reverse = TRUE;
  494.         reverse_flag_specified = TRUE;
  495.         break;
  496.         case 's':
  497.         verbose = FALSE;
  498.         break;
  499.         case 'S':
  500.         skip_rest_of_patch = TRUE;
  501.         break;
  502.         case 'u':
  503.         diff_type = UNI_DIFF;
  504.         break;
  505.         case 'v':
  506.         version();
  507.         break;
  508. #ifdef DEBUGGING
  509.         case 'x':
  510.         debug = atoi(s+1);
  511.         break;
  512. #endif
  513.         default:
  514.         fprintf(stderr, "patch: unrecognized option `%s'\n", Argv[0]);
  515.         fprintf(stderr, "\
  516. Usage: patch [-ceflnNRsSuv] [-b backup-ext] [-B backup-prefix] [-d directory]\n\
  517.        [-D symbol] [-Fmax-fuzz] [-o out-file] [-p[strip-count]]\n\
  518.        [-r rej-name] [origfile] [patchfile] [[+] [options] [origfile]...]\n\
  519. ");
  520.         my_exit(1);
  521.         }
  522.     }
  523.     }
  524. }
  525.  
  526. /* Attempt to find the right place to apply this hunk of patch. */
  527.  
  528. LINENUM
  529. locate_hunk(fuzz)
  530. LINENUM fuzz;
  531. {
  532.     Reg1 LINENUM first_guess = pch_first() + last_offset;
  533.     Reg2 LINENUM offset;
  534.     LINENUM pat_lines = pch_ptrn_lines();
  535.     Reg3 LINENUM max_pos_offset = input_lines - first_guess
  536.                 - pat_lines + 1; 
  537.     Reg4 LINENUM max_neg_offset = first_guess - last_frozen_line - 1
  538.                 + pch_context();
  539.  
  540.     if (!pat_lines)            /* null range matches always */
  541.     return first_guess;
  542.     if (max_neg_offset >= first_guess)    /* do not try lines < 0 */
  543.     max_neg_offset = first_guess - 1;
  544.     if (first_guess <= input_lines && patch_match(first_guess, Nulline, fuzz))
  545.     return first_guess;
  546.     for (offset = 1; ; offset++) {
  547.     Reg5 bool check_after = (offset <= max_pos_offset);
  548.     Reg6 bool check_before = (offset <= max_neg_offset);
  549.  
  550.     if (check_after && patch_match(first_guess, offset, fuzz)) {
  551. #ifdef DEBUGGING
  552.         if (debug & 1)
  553.         say3("Offset changing from %ld to %ld\n", last_offset, offset);
  554. #endif
  555.         last_offset = offset;
  556.         return first_guess+offset;
  557.     }
  558.     else if (check_before && patch_match(first_guess, -offset, fuzz)) {
  559. #ifdef DEBUGGING
  560.         if (debug & 1)
  561.         say3("Offset changing from %ld to %ld\n", last_offset, -offset);
  562. #endif
  563.         last_offset = -offset;
  564.         return first_guess-offset;
  565.     }
  566.     else if (!check_before && !check_after)
  567.         return Nulline;
  568.     }
  569. }
  570.  
  571. /* We did not find the pattern, dump out the hunk so they can handle it. */
  572.  
  573. void
  574. abort_hunk()
  575. {
  576.     Reg1 LINENUM i;
  577.     Reg2 LINENUM pat_end = pch_end();
  578.     /* add in last_offset to guess the same as the previous successful hunk */
  579.     LINENUM oldfirst = pch_first() + last_offset;
  580.     LINENUM newfirst = pch_newfirst() + last_offset;
  581.     LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
  582.     LINENUM newlast = newfirst + pch_repl_lines() - 1;
  583.     char *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
  584.     char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
  585.  
  586.     fprintf(rejfp, "***************\n");
  587.     for (i=0; i<=pat_end; i++) {
  588.     switch (pch_char(i)) {
  589.     case '*':
  590.         if (oldlast < oldfirst)
  591.         fprintf(rejfp, "*** 0%s\n", stars);
  592.         else if (oldlast == oldfirst)
  593.         fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
  594.         else
  595.         fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst, oldlast, stars);
  596.         break;
  597.     case '=':
  598.         if (newlast < newfirst)
  599.         fprintf(rejfp, "--- 0%s\n", minuses);
  600.         else if (newlast == newfirst)
  601.         fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
  602.         else
  603.         fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses);
  604.         break;
  605.     case '\n':
  606.         fprintf(rejfp, "%s", pfetch(i));
  607.         break;
  608.     case ' ': case '-': case '+': case '!':
  609.         fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
  610.         break;
  611.     default:
  612.         say1("Fatal internal error in abort_hunk().\n"); 
  613.         abort();
  614.     }
  615.     }
  616. }
  617.  
  618. /* We found where to apply it (we hope), so do it. */
  619.  
  620. void
  621. apply_hunk(where)
  622. LINENUM where;
  623. {
  624.     Reg1 LINENUM old = 1;
  625.     Reg2 LINENUM lastline = pch_ptrn_lines();
  626.     Reg3 LINENUM new = lastline+1;
  627. #define OUTSIDE 0
  628. #define IN_IFNDEF 1
  629. #define IN_IFDEF 2
  630. #define IN_ELSE 3
  631.     Reg4 int def_state = OUTSIDE;
  632.     Reg5 bool R_do_defines = do_defines;
  633.     Reg6 LINENUM pat_end = pch_end();
  634.  
  635.     where--;
  636.     while (pch_char(new) == '=' || pch_char(new) == '\n')
  637.     new++;
  638.     
  639.     while (old <= lastline) {
  640.     if (pch_char(old) == '-') {
  641.         copy_till(where + old - 1);
  642.         if (R_do_defines) {
  643.         if (def_state == OUTSIDE) {
  644.             fputs(not_defined, ofp);
  645.             def_state = IN_IFNDEF;
  646.         }
  647.         else if (def_state == IN_IFDEF) {
  648.             fputs(else_defined, ofp);
  649.             def_state = IN_ELSE;
  650.         }
  651.         fputs(pfetch(old), ofp);
  652.         }
  653.         last_frozen_line++;
  654.         old++;
  655.     }
  656.     else if (new > pat_end) {
  657.         break;
  658.     }
  659.     else if (pch_char(new) == '+') {
  660.         copy_till(where + old - 1);
  661.         if (R_do_defines) {
  662.         if (def_state == IN_IFNDEF) {
  663.             fputs(else_defined, ofp);
  664.             def_state = IN_ELSE;
  665.         }
  666.         else if (def_state == OUTSIDE) {
  667.             fputs(if_defined, ofp);
  668.             def_state = IN_IFDEF;
  669.         }
  670.         }
  671.         fputs(pfetch(new), ofp);
  672.         new++;
  673.     }
  674.     else if (pch_char(new) != pch_char(old)) {
  675.         say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
  676.         pch_hunk_beg() + old,
  677.         pch_hunk_beg() + new);
  678. #ifdef DEBUGGING
  679.         say3("oldchar = '%c', newchar = '%c'\n",
  680.         pch_char(old), pch_char(new));
  681. #endif
  682.         my_exit(1);
  683.     }
  684.     else if (pch_char(new) == '!') {
  685.         copy_till(where + old - 1);
  686.         if (R_do_defines) {
  687.            fputs(not_defined, ofp);
  688.            def_state = IN_IFNDEF;
  689.         }
  690.         while (pch_char(old) == '!') {
  691.         if (R_do_defines) {
  692.             fputs(pfetch(old), ofp);
  693.         }
  694.         last_frozen_line++;
  695.         old++;
  696.         }
  697.         if (R_do_defines) {
  698.         fputs(else_defined, ofp);
  699.         def_state = IN_ELSE;
  700.         }
  701.         while (pch_char(new) == '!') {
  702.         fputs(pfetch(new), ofp);
  703.         new++;
  704.         }
  705.     }
  706.     else {
  707.         assert(pch_char(new) == ' ');
  708.         old++;
  709.         new++;
  710.         if (R_do_defines && def_state != OUTSIDE) {
  711.         fputs(end_defined, ofp);
  712.         def_state = OUTSIDE;
  713.         }
  714.     }
  715.     }
  716.     if (new <= pat_end && pch_char(new) == '+') {
  717.     copy_till(where + old - 1);
  718.     if (R_do_defines) {
  719.         if (def_state == OUTSIDE) {
  720.             fputs(if_defined, ofp);
  721.         def_state = IN_IFDEF;
  722.         }
  723.         else if (def_state == IN_IFNDEF) {
  724.         fputs(else_defined, ofp);
  725.         def_state = IN_ELSE;
  726.         }
  727.     }
  728.     while (new <= pat_end && pch_char(new) == '+') {
  729.         fputs(pfetch(new), ofp);
  730.         new++;
  731.     }
  732.     }
  733.     if (R_do_defines && def_state != OUTSIDE) {
  734.     fputs(end_defined, ofp);
  735.     }
  736. }
  737.  
  738. /* Open the new file. */
  739.  
  740. void
  741. init_output(name)
  742. char *name;
  743. {
  744.     ofp = fopen(name, "w");
  745.     if (ofp == Nullfp)
  746.     fatal2("patch: can't create %s.\n", name);
  747. }
  748.  
  749. /* Open a file to put hunks we can't locate. */
  750.  
  751. void
  752. init_reject(name)
  753. char *name;
  754. {
  755.     rejfp = fopen(name, "w");
  756.     if (rejfp == Nullfp)
  757.     fatal2("patch: can't create %s.\n", name);
  758. }
  759.  
  760. /* Copy input file to output, up to wherever hunk is to be applied. */
  761.  
  762. void
  763. copy_till(lastline)
  764. Reg1 LINENUM lastline;
  765. {
  766.     Reg2 LINENUM R_last_frozen_line = last_frozen_line;
  767.  
  768.     if (R_last_frozen_line > lastline)
  769.     say1("patch: misordered hunks! output will be garbled.\n");
  770.     while (R_last_frozen_line < lastline) {
  771.     dump_line(++R_last_frozen_line);
  772.     }
  773.     last_frozen_line = R_last_frozen_line;
  774. }
  775.  
  776. /* Finish copying the input file to the output file. */
  777.  
  778. void
  779. spew_output()
  780. {
  781. #ifdef DEBUGGING
  782.     if (debug & 256)
  783.     say3("il=%ld lfl=%ld\n",input_lines,last_frozen_line);
  784. #endif
  785.     if (input_lines)
  786.     copy_till(input_lines);        /* dump remainder of file */
  787.     Fclose(ofp);
  788.     ofp = Nullfp;
  789. }
  790.  
  791. /* Copy one line from input to output. */
  792.  
  793. void
  794. dump_line(line)
  795. LINENUM line;
  796. {
  797.     Reg1 char *s;
  798.     Reg2 char R_newline = '\n';
  799.  
  800.     /* Note: string is not null terminated. */
  801.     for (s=ifetch(line, 0); putc(*s, ofp) != R_newline; s++) ;
  802. }
  803.  
  804. /* Does the patch pattern match at line base+offset? */
  805.  
  806. bool
  807. patch_match(base, offset, fuzz)
  808. LINENUM base;
  809. LINENUM offset;
  810. LINENUM fuzz;
  811. {
  812.     Reg1 LINENUM pline = 1 + fuzz;
  813.     Reg2 LINENUM iline;
  814.     Reg3 LINENUM pat_lines = pch_ptrn_lines() - fuzz;
  815.  
  816.     for (iline=base+offset+fuzz; pline <= pat_lines; pline++,iline++) {
  817.     if (canonicalize) {
  818.         if (!similar(ifetch(iline, (offset >= 0)),
  819.              pfetch(pline),
  820.              pch_line_len(pline) ))
  821.         return FALSE;
  822.     }
  823.     else if (strnNE(ifetch(iline, (offset >= 0)),
  824.            pfetch(pline),
  825.            pch_line_len(pline) ))
  826.         return FALSE;
  827.     }
  828.     return TRUE;
  829. }
  830.  
  831. /* Do two lines match with canonicalized white space? */
  832.  
  833. bool
  834. similar(a,b,len)
  835. Reg1 char *a;
  836. Reg2 char *b;
  837. Reg3 int len;
  838. {
  839.     while (len) {
  840.     if (isspace(*b)) {        /* whitespace (or \n) to match? */
  841.         if (!isspace(*a))        /* no corresponding whitespace? */
  842.         return FALSE;
  843.         while (len && isspace(*b) && *b != '\n')
  844.         b++,len--;        /* skip pattern whitespace */
  845.         while (isspace(*a) && *a != '\n')
  846.         a++;            /* skip target whitespace */
  847.         if (*a == '\n' || *b == '\n')
  848.         return (*a == *b);    /* should end in sync */
  849.     }
  850.     else if (*a++ != *b++)        /* match non-whitespace chars */
  851.         return FALSE;
  852.     else
  853.         len--;            /* probably not necessary */
  854.     }
  855.     return TRUE;            /* actually, this is not reached */
  856.                     /* since there is always a \n */
  857. }
  858.  
  859. /* Exit with cleanup. */
  860.  
  861. void
  862. my_exit(status)
  863. int status;
  864. {
  865.     Unlink(TMPINNAME);
  866.     if (!toutkeep) {
  867.     Unlink(TMPOUTNAME);
  868.     }
  869.     if (!trejkeep) {
  870.     Unlink(TMPREJNAME);
  871.     }
  872.     Unlink(TMPPATNAME);
  873.     exit(status);
  874. }
  875.